﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using produccion.clases;
using produccion.AccesoDatos;
using System.Collections.ObjectModel;
using System.Windows.Input;
using System.ComponentModel;
using System.Diagnostics;
using System.Windows.Controls;
using System.Data;




namespace produccion.vistamodelo
{
    class VMAdministrarOpciones:ViewModelBase
    {
        #region campos

       
        CLSMAEOPCP _raiz = new CLSMAEOPCP();
        List<CLSMAEOPCP> _actOrden = new List<CLSMAEOPCP>();
        List<CLSMAEOPCP> _delOpcion = new List<CLSMAEOPCP>();
        List<CLSMAEOPCP> _actOpcion = new List<CLSMAEOPCP>();
        List<CLSMAEOPCP> _insOpcion = new List<CLSMAEOPCP>();
        ProcesoProduccionRepositorio rep = new ProcesoProduccionRepositorio();


        #endregion

        #region constructor

        public VMAdministrarOpciones()
            {
                try
                {
                    cargarMenu();
                    if (MDOgeneral.conexion == null || MDOgeneral.conexion.State == ConnectionState.Closed)
                    {
                        MDOgeneral.conectar();
                    }
                    strTituloVentana = "Administrar Opciones" + " - Usuario: " + MDOgeneral.usuario + " - [FRMAdministrarOpciones]";
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

        #endregion

        #region metodos

        void cargarMenu() {

            try
            {
                if (opciones != null)
                {
                    opciones = new ObservableCollection<VMopcionesMenu>();
                    opciones.Clear();
                    base.OnPropertyChanged("opciones");
                }

                _raiz = new CLSMAEOPCP();
                _raiz.NOMBRE_OPC = "MENU";
                _raiz.TIPO_OPC = "M";
                _raiz.CODPADRE_OPC = null;
                _raiz.padre = null;
                _raiz.CODHIJO_OPC = "0";
                _raiz.ORDEN_OPC = "1";
                List<CLSMAEOPCP> lisOpciones = _raiz.ConsultarMenu();
                (from cust in lisOpciones select cust.padre=_raiz).ToList();
                _raiz.hijos=lisOpciones;
                List<CLSMAEOPCP> lisOp=new List<CLSMAEOPCP>();
                lisOp.Add(_raiz);
                List<VMopcionesMenu> all = (from cust in lisOp select new VMopcionesMenu(cust, null, consNuevoHijo)).ToList();
                opciones=new ObservableCollection<VMopcionesMenu>(all);
                base.OnPropertyChanged("opciones");
                padre = opciones[0];
               
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        void guardar() {
            try{

                _actOrden = new List<CLSMAEOPCP>();
                _delOpcion = new List<CLSMAEOPCP>();
                _actOpcion = new List<CLSMAEOPCP>();
                _insOpcion = new List<CLSMAEOPCP>();

                ReeOrdenar(opciones);
                getOrden(opciones);
                getDelOpcion(opciones);
                getActOpcion(opciones);
                getInsOpcion(opciones);

                if (rep.GuardarOpciones(_actOrden, _delOpcion, _actOpcion, _insOpcion))
                {
                    msn.texto = "Los cambios en el Menu de Usuarios fueron guardados.";
                    msn.tipo = true;
                }
                else {
                    msn.texto = "Los cambios en el Menu de Usuarios no pueden ser guardados.";
                    msn.tipo=false;
                }
                cargarMenu();
            
            }
            catch (Exception ex){MessageBox.Show(ex.Message);}
        }

        Boolean ReeOrdenar(ObservableCollection<VMopcionesMenu> _hijos) {
            try {

                if (_hijos != null)
                {
                    (from cust in _hijos select cust.ReeOrdenarHijos()).ToList();

                    (from cust in _hijos select ReeOrdenar(cust.hijos)).ToList();
                }
             
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }

            return true;
        }

        Boolean getOrden(ObservableCollection<VMopcionesMenu> _hijos) {
           
            if (_hijos != null)
            {
                _actOrden = (from cust in _hijos where !String.IsNullOrEmpty(cust.codpadre)&&cust.cambioOrden && !cust.Nuevo  select cust.getOpcion()).Union(_actOrden).ToList();
                (from cust in _hijos select getOrden(cust.hijos)).ToList();
            }
            return true;
        }

        Boolean getDelOpcion(ObservableCollection<VMopcionesMenu> _hijos)
        {

            if (_hijos != null)
            {
                _delOpcion = (from cust in _hijos where !String.IsNullOrEmpty(cust.codpadre) && cust.Eliminar.Equals("S") select cust.getOpcion()).Union(_delOpcion).ToList();
                (from cust in _hijos select getDelOpcion(cust.hijos)).ToList();
            }
            return true;
        }

        Boolean getActOpcion(ObservableCollection<VMopcionesMenu> _hijos)
        {

            if (_hijos != null)
            {
                _actOpcion = (from cust in _hijos where !String.IsNullOrEmpty(cust.codpadre) && cust.Cambio && !cust.Nuevo && cust.IsValid select cust.getOpcion()).Union(_actOpcion).ToList();
                (from cust in _hijos select getActOpcion(cust.hijos)).ToList();
            }
            return true;
        }

        Boolean getInsOpcion(ObservableCollection<VMopcionesMenu> _hijos)
        {
            if (_hijos != null)
            {
                _insOpcion = (from cust in _hijos where !String.IsNullOrEmpty(cust.codpadre) && cust.Nuevo && cust.IsValid select cust.getOpcion()).Union(_insOpcion).ToList();
                (from cust in _hijos select getInsOpcion(cust.hijos)).ToList();
            }
            return true;
        }

        int getMaxHijo(ObservableCollection<VMopcionesMenu> _hijos,int max)
        {
            if (_hijos != null)
            {
                (from cust in _hijos where !String.IsNullOrEmpty(cust.codpadre) where Convert.ToInt32(cust.codhijo) > max select max = Convert.ToInt32(cust.codhijo)).ToList();
                (from cust in _hijos select max=getMaxHijo(cust.hijos,max)).ToList();
            }
            return max;
        }

        string consNuevoHijo()
        {
            try
            {
               return (getMaxHijo(opciones,0)+1).ToString();

            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }

            return "0";
        }

        void Buscar(object txtBuscar) {
            try { 
             PerformSearch();
             ((TextBox)txtBuscar).Focus();
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }
       
        IEnumerator<VMopcionesMenu> _buscandoapp;
        public void PerformSearch()
        {
            if (String.IsNullOrEmpty(texMenBus) || String.IsNullOrWhiteSpace(texMenBus))
                return;

            if (_buscandoapp == null || !_buscandoapp.MoveNext())
                this.VerifyMatchingItemEnumerator();

            var item = _buscandoapp.Current;

            if (item == null)
                return;
            camm = true;
            item.IsExpanded = true;
            item.IsSelected = true;
            sel = item;

            VMopcionesMenu a = item;
            msn.texto = "Coincidencia encontrada '" + item.nombre + "'.";
            msn.tipo = true;

            while (a.padre != null)
            {
                a.padre.IsExpanded = true;
                a.padre.IsSelected = false;
                a = a.padre;
            }
        }

        void VerifyMatchingItemEnumerator()
        {
            var matches = this.FindMatches(texMenBus, opciones[0]);
            _buscandoapp = matches.GetEnumerator();

            if (!_buscandoapp.MoveNext())
            {
                msn.texto = "No se encuentran coincidencias para su busqueda.";
                msn.tipo = false;
            }
        }
        IEnumerable<VMopcionesMenu> FindMatches(string searchText, VMopcionesMenu item)
        {

        
            if (item.nombre.ToUpper().Contains(searchText.ToUpper()))
                yield return item;

            foreach (VMopcionesMenu child in item.hijos)
                foreach (VMopcionesMenu match in this.FindMatches(searchText, child))
                    yield return match;
        }

        void Salir(object ventana) {
            try {
                ((Window)ventana).Close();
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        
        }

        #endregion

        #region interfaces publicas

        public ObservableCollection<VMopcionesMenu> opciones { get; set; }

        RelayCommand _cmdGuardar;
        public ICommand cmdGuardar
        {
            get
            {

                if (_cmdGuardar == null)
                {
                    _cmdGuardar = new RelayCommand(x => guardar());
                }
                return _cmdGuardar;
            }
        }
        
        RelayCommand _cmdBuscar;
        public ICommand cmdBuscar
        {
            get
            {

                if (_cmdBuscar == null)
                {
                    _cmdBuscar = new RelayCommand(Buscar);
                }
                return _cmdBuscar;
            }
        }

        RelayCommand _cmdSalir;
        public ICommand cmdSalir
        {
            get
            {
                if (_cmdSalir == null)
                {
                    _cmdSalir = new RelayCommand(Salir);
                }
                return _cmdSalir;
            }
        }

        private string _texMenBus;
        public string texMenBus {
            get { return _texMenBus; }
            set { _texMenBus = value;
            base.OnPropertyChanged("texMenBus");
            _buscandoapp = null;
            }
        }

        MDOgeneral.mensaje _msn = new MDOgeneral.mensaje();
        public MDOgeneral.mensaje msn {
            get { return _msn; }
            set {
                _msn = value; 
                base.OnPropertyChanged("msn");
            }
        }

        private Boolean _camm = false;
        public Boolean camm
        {
            get { return _camm; }
            set
            {
                _camm = value;
                base.OnPropertyChanged("camm");
            }
        }

        private VMopcionesMenu _sel;
        public VMopcionesMenu sel
        {
            get { return _sel; }
            set
            {
                _sel = value;
                base.OnPropertyChanged("sel");
            }
        }

        private VMopcionesMenu _padre;
        public VMopcionesMenu padre
        {
            get { return _padre; }
            set
            {
                _padre = value;
                base.OnPropertyChanged("padre");
            }
        }

        private string _strTituloVentana;
        public string strTituloVentana
        {
            get { return _strTituloVentana; }
            set { _strTituloVentana = value; base.OnPropertyChanged("strTituloVentana"); }
        }
            

        #endregion

        #region vistas modelo
      
        public class VMopcionesMenu : ViewModelBase, IDataErrorInfo
        {

            #region campos
            private CLSMAEOPCP _menu = new CLSMAEOPCP();
            #endregion

            #region constructores


            public VMopcionesMenu(CLSMAEOPCP menu, VMopcionesMenu _padre, ConsNuevoHijo _consNuevoHijo)
            {
                try
                {
                    _menu = menu;
                    this.cargarHijos(_consNuevoHijo);
                    nombreView = _menu.NOMBRE_OPC;
                    padre = _padre;

                    consNuevoHijo += _consNuevoHijo;
                                   

                    if (_padre == null) {

                        IsExpanded = true;
                    }
              
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            public VMopcionesMenu() { }

            #endregion

            #region metodos

            void cargarHijos(ConsNuevoHijo _consNuevoHijo)
            {
                try
                {                                 
                    if (_menu.hijos != null)
                    {
                        List<VMopcionesMenu> all = (from cust in _menu.hijos select new VMopcionesMenu(cust, this, _consNuevoHijo)).ToList();
                        hijos = new ObservableCollection<VMopcionesMenu>(all);
                    }
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            void Modificar() {

                try
                {
                    IsSelected = true;
                    IsEdit = true;
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            void NuevaCarpeta() {
                try {

                    CLSMAEOPCP _carpeta = new CLSMAEOPCP();
                    _carpeta.NOMBRE_OPC="Nueva carpeta";
                    _carpeta.TIPO_OPC="M";
                    _carpeta.CODHIJO_OPC=consNuevoHijo();
                

                    if (_menu.TIPO_OPC.Equals("M"))
                    {
                        _carpeta.padre = _menu;
                        _carpeta.CODPADRE_OPC = this.codhijo;
                        if (Eliminar.Equals("S")) return;
                        VMopcionesMenu op = new VMopcionesMenu(_carpeta, this, consNuevoHijo);
                        if (hijos == null) { hijos = new ObservableCollection<VMopcionesMenu>(); }
                        hijos.Add(op);
                        op.Nuevo = true;
                        op.IsSelected = true;
                        op.Modificar();
                        int des = hijos.Count(x=>x.tipo.Equals("M"));
                        (from cust in hijos where Convert.ToInt32(cust.orden) >= des select cust.orden = (Convert.ToInt32(cust.orden) + 1).ToString()).ToList();
                        hijos.Move(hijos.Count - 1,des-1);
                        op.orden = des.ToString();
                        IsExpanded = true;
                        base.OnPropertyChanged("hijos");
                    }
                    else {
                        _carpeta.padre = _menu.padre;
                        _carpeta.CODPADRE_OPC = this.codpadre;
                        if (padre.Eliminar.Equals("S")) return;
                        VMopcionesMenu op = new VMopcionesMenu(_carpeta, padre, consNuevoHijo);
                        if (padre.hijos == null) { padre.hijos = new ObservableCollection<VMopcionesMenu>(); }
                        padre.hijos.Add(op);
                        int des = padre.hijos.Count(x=>x.tipo.Equals("M"));
                        (from cust in padre.hijos where Convert.ToInt32(cust.orden) >= des select cust.orden = (Convert.ToInt32(cust.orden) + 1).ToString()).ToList();
                        padre.hijos.Move(padre.hijos.Count-1, des-1);
                        op.orden = des.ToString();
                        op.Nuevo = true;
                        op.IsSelected = true;
                        op.Modificar();
                        base.OnPropertyChanged("padre");
                    }
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            void NuevaOpcion()
            {
                try
                {
                    CLSMAEOPCP _opcion = new CLSMAEOPCP();
                    _opcion.NOMBRE_OPC = "Nueva Opcion";
                    _opcion.TIPO_OPC = "A";
                    _opcion.CODHIJO_OPC = consNuevoHijo();
                 
                    if (_menu.TIPO_OPC.Equals("M"))
                    {
                        _opcion.padre = _menu;
                        _opcion.CODPADRE_OPC = this.codhijo;
                        if (Eliminar.Equals("S")) return;
                        VMopcionesMenu op = new VMopcionesMenu(_opcion, this, consNuevoHijo);
                        if (hijos == null) { hijos = new ObservableCollection<VMopcionesMenu>(); }
                        hijos.Add(op);
                        op.orden = (hijos.Count).ToString();
                        op.Nuevo = true;
                        op.IsSelected = true;
                        op.Modificar();
                        IsExpanded = true;
                        base.OnPropertyChanged("hijos");
                    }
                    else
                    {
                        _opcion.padre = _menu.padre;
                        _opcion.CODPADRE_OPC = this.codpadre;
                        if (padre.Eliminar.Equals("S")) return;
                        VMopcionesMenu op = new VMopcionesMenu(_opcion, padre, consNuevoHijo);
                        if (padre.hijos == null) { padre.hijos = new ObservableCollection<VMopcionesMenu>(); }
                        padre.hijos.Add(op);
                        op.orden = (padre.hijos.Count).ToString();
                        op.Nuevo = true;
                        op.IsSelected = true;
                        op.Modificar();
                        base.OnPropertyChanged("padre");

                    }
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            void Subir() {
                try {

                    if (padre.hijos.IndexOf(this) - 1 == -1) { return; }
                    if (!padre.hijos[padre.hijos.IndexOf(this) - 1].tipo.Equals(this.tipo)){  return;   }

                    padre.hijos[padre.hijos.IndexOf(this) - 1].orden = orden;
                    orden = (Convert.ToInt32(orden) - 1).ToString();
                    padre.hijos.Move(padre.hijos.IndexOf(this), padre.hijos.IndexOf(this)-1);
                 
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            void Bajar()
            {
                try
                {
                    if (padre.hijos.IndexOf(this) + 1 == padre.hijos.Count()) { return; }
                    if (!padre.hijos[padre.hijos.IndexOf(this) + 1].tipo.Equals(this.tipo)) { return; }

                    padre.hijos[padre.hijos.IndexOf(this) + 1].orden = orden;
                    orden = (Convert.ToInt32(orden) + 1).ToString();
                    padre.hijos.Move(padre.hijos.IndexOf(this), padre.hijos.IndexOf(this) + 1);
                 
                 
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            public Boolean ReeOrdenarHijos() {
                try {
                    if (hijos != null)
                    {
                        int i = 1;
                        (from cust in hijos where !cust.Eliminar.Equals("S") select cust.orden = (i++).ToString()).ToList();
                    }
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
                return true;
            }

            public Boolean EliminarHijos(ObservableCollection<VMopcionesMenu> _lisHijos) {
                try {
                    if (_lisHijos != null)
                    {
                        for (int i = 0; i <= _lisHijos.Count - 1; i++) {

                            int aux = i;
                            if (_lisHijos[i].Nuevo)
                            {   
                                i = i - 1;
                            }
                            _lisHijos[aux]._Eliminar = "S";
                            _lisHijos[aux].OnPropertyChanged("Eliminar");
                            _lisHijos[aux]._IsExpanded= true;
                            _lisHijos[aux].OnPropertyChanged("IsExpanded");
                            EliminarHijos(_lisHijos[aux].hijos);
                        }
                    }
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
                return true;
            }

            public Boolean DesEliminarHijos(ObservableCollection<VMopcionesMenu> _lisHijos)
            {
                try
                {
                    if (_lisHijos != null)
                    {
                        for (int i = 0; i <= _lisHijos.Count - 1; i++)
                        {
                            _lisHijos[i]._Eliminar = "N";
                            _lisHijos[i].OnPropertyChanged("Eliminar");
                            _lisHijos[i].IsExpanded = true;
                            _lisHijos[i].OnPropertyChanged("IsExpanded");
                            DesEliminarHijos(_lisHijos[i].hijos);
                        }
                    }
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
                return true;
            }

            public Boolean DesEliminarPadre(VMopcionesMenu _padre)
            {
                try
                {
                    if (_padre != null) {
                        _padre._Eliminar = "N";
                        _padre.OnPropertyChanged("Eliminar");
                        _padre.IsExpanded = true;
                        _padre.OnPropertyChanged("IsExpanded");
                         DesEliminarPadre(_padre.padre);
                    }
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
                return true;
            }

            public CLSMAEOPCP getOpcion() {
                return _menu;            
            }

            public delegate string ConsNuevoHijo();

            #endregion

            #region interfaces publicas

            public ConsNuevoHijo consNuevoHijo;

            public string nombre
            {
                get { return _menu.NOMBRE_OPC; }
                set {
                    if (_menu.NOMBRE_OPC != value) Cambio = true;
                    _menu.NOMBRE_OPC = value; base.OnPropertyChanged("nombre"); }
            }

            private string _nombreView;
            public string nombreView
            {
                get { return _nombreView; }
                set { _nombreView = value;
                base.OnPropertyChanged("nombreView");
                }
             
            }
          
            public string tipo
            {
                get { return _menu.TIPO_OPC; }
                set { _menu.TIPO_OPC = value; base.OnPropertyChanged("tipo"); }
            }

            public string formulario
            {
                get { return _menu.FORMUL_OPC; }
                set {
                    if (_menu.FORMUL_OPC != value) Cambio = true;
                    _menu.FORMUL_OPC = value; base.OnPropertyChanged("formulario"); }
            }

            private ObservableCollection<VMopcionesMenu> _hijos = new ObservableCollection<VMopcionesMenu>(); 
            public ObservableCollection<VMopcionesMenu> hijos {
                get { return _hijos; }
                set { _hijos = value;
                base.OnPropertyChanged("hijos");
                }
            }

            public VMopcionesMenu padre { get; set; }

            private Boolean _IsEdit = false;
            public Boolean IsEdit {
                get { return _IsEdit; }
                set { _IsEdit = value;
                if (_IsEdit == false&&IsValid) { nombreView = nombre; }
                base.OnPropertyChanged("IsEdit");
                }
            }

            RelayCommand _cmdModificar;
            public ICommand cmdModificar
            {
                get
                {

                    if (_cmdModificar == null)
                    {
                        _cmdModificar = new RelayCommand(x=>Modificar());
                    }
                    return _cmdModificar;
                }
            }

            RelayCommand _cmdNuevaCarpeta;
            public ICommand cmdNuevaCarpeta
            {
                get
                {

                    if (_cmdNuevaCarpeta == null)
                    {
                        _cmdNuevaCarpeta = new RelayCommand(x => NuevaCarpeta());
                    }
                    return _cmdNuevaCarpeta;
                }
            }

            RelayCommand _cmdNuevaOpcion;
            public ICommand cmdNuevaOpcion
            {
                get
                {

                    if (_cmdNuevaOpcion == null)
                    {
                        _cmdNuevaOpcion = new RelayCommand(x => NuevaOpcion());
                    }
                    return _cmdNuevaOpcion;
                }
            }

            RelayCommand _cmdSubir;
            public ICommand cmdSubir
            {
                get
                {

                    if (_cmdSubir == null)
                    {
                        _cmdSubir= new RelayCommand(x => Subir());
                    }
                    return _cmdSubir;
                }
            }

            RelayCommand _cmdBajar;
            public ICommand cmdBajar
            {
                get
                {

                    if (_cmdBajar == null)
                    {
                        _cmdBajar = new RelayCommand(x => Bajar());
                    }
                    return _cmdBajar;
                }
            }

            private Boolean _IsExpanded;
            public Boolean IsExpanded
            {
                get { return _IsExpanded; }
                set
                {
                    _IsExpanded = value;
                    base.OnPropertyChanged("IsExpanded");
                }
            }

            private Boolean _IsSelected;
            public Boolean IsSelected
            {
                get { return _IsSelected; }
                set
                {
                    _IsSelected = value;
                    if (_IsSelected == false) { IsEdit = false; }
                    base.OnPropertyChanged("IsSelected");
                }
            }

            private Boolean _Cambio=false;
            public Boolean Cambio {
                get { return _Cambio; }
                set { _Cambio = value;
                base.OnPropertyChanged("Cambio");
                }
            }

            private string _Eliminar = "N";
            public string Eliminar {
                get { return _Eliminar; }
                set { _Eliminar = value;

                if (_Eliminar.Equals("S")) { IsExpanded = true; }

                if (Nuevo == true && _Eliminar.Equals("S")) { padre.hijos.Remove(this);
                }
                else
                {
                    if (tipo.Equals("M") && _Eliminar.Equals("S")) EliminarHijos(hijos);
                    if (tipo.Equals("M") && _Eliminar.Equals("N")) DesEliminarHijos(hijos);
                    if (_Eliminar.Equals("N")) DesEliminarPadre(padre);
                }
                base.OnPropertyChanged("Eliminar");
                }
            }

            private Boolean _Nuevo = false;
            public Boolean Nuevo
            {
                get { return _Nuevo; }
                set
                {
                    _Nuevo = value;
                    base.OnPropertyChanged("Nuevo");
                }
            }
            
            public string codpadre {
                get { return _menu.CODPADRE_OPC; }
                set { _menu.CODPADRE_OPC = value;
                base.OnPropertyChanged("codpadre");
                }
            }

            public string codhijo {
                get { return _menu.CODHIJO_OPC; }
                set { _menu.CODHIJO_OPC = value;
                base.OnPropertyChanged("codhijo");
                }
            }

            public string orden
            {
                get { return _menu.ORDEN_OPC; }
                set
                {

                    if (_menu.ORDEN_OPC != value) cambioOrden = true;
                    _menu.ORDEN_OPC = value;
                    base.OnPropertyChanged("orden");
                }
            }

            private Boolean _cambioOrden = false;
            public Boolean cambioOrden {
                get { return _cambioOrden; }
                set { _cambioOrden = value;
                base.OnPropertyChanged("cambioOrden");
                }
            }
                       
            #endregion

            #region IDataErrorInfo Members

            string IDataErrorInfo.Error { get { return null; } }

            string IDataErrorInfo.this[string propertyName]
            {
                get { return this.GetValidationError(propertyName); }
            }

            #endregion

            #region Validation

            /// <summary>
            /// Returns true if this object has no validation errors.
            /// </summary>
            public bool IsValid
            {
                get
                {
                    foreach (string property in ValidatedProperties)
                        if (GetValidationError(property) != null)
                            return false;

                    return true;
                }
                set {
                    IsValid = value;
                    base.OnPropertyChanged("IsValid");
                
                }
            }

            static readonly string[] ValidatedProperties = 
            { 
            "nombre",
            "formulario"
            };

            string GetValidationError(string propertyName)
            {
                if (Array.IndexOf(ValidatedProperties, propertyName) < 0)
                    return null;

                string error = null;

                switch (propertyName)
                {
                    case "nombre":
                        error = this.Validatenombre();
                        break;
                    case "formulario":
                        error = this.Validateformulario();
                        break;
                     default:
                        Debug.Fail("Unexpected property being validated on Customer: " + propertyName);
                     break;
                }
                return error;
            }

            string Validatenombre()
            {

                if (String.IsNullOrEmpty(nombre)) { return "El nombre no puede estar vacio."; }

                return null;
            }

            string Validateformulario()
            {

                
                if (tipo.Equals("A")&&String.IsNullOrEmpty(formulario)) { return "El formulario no puede estar vacio."; }
                return null;
            }

              

            #endregion


        }
        #endregion
   

    }
}
